/**
 * 任务管理器类
 * 负责任务的创建、编辑、删除、完成状态管理以及与番茄时钟的关联
 */
class TaskManager {
    constructor() {
        this.tasks = [];
        this.currentTaskId = null;
        this.taskIdCounter = 1;
        this.listeners = [];
        
        this.loadTasks();
    }

    /**
     * 默认任务数据结构
     */
    get defaultTaskData() {
        return {
            tasks: [],
            currentTaskId: null,
            taskIdCounter: 1
        };
    }

    /**
     * 加载任务数据
     */
    loadTasks() {
        try {
            const data = localStorage.getItem('pomodoroTasks');
            if (data) {
                const taskData = JSON.parse(data);
                this.tasks = taskData.tasks || [];
                this.currentTaskId = taskData.currentTaskId || null;
                this.taskIdCounter = taskData.taskIdCounter || 1;
            }
        } catch (error) {
            console.error('加载任务数据失败:', error);
            this.resetTasks();
        }
    }

    /**
     * 保存任务数据
     */
    saveTasks() {
        try {
            const taskData = {
                tasks: this.tasks,
                currentTaskId: this.currentTaskId,
                taskIdCounter: this.taskIdCounter
            };
            localStorage.setItem('pomodoroTasks', JSON.stringify(taskData));
            this.notifyListeners('tasksUpdated', { tasks: this.tasks });
        } catch (error) {
            console.error('保存任务数据失败:', error);
        }
    }

    /**
     * 创建新任务
     * @param {string} name - 任务名称
     * @param {number} estimatedPomodoros - 预估番茄数
     * @param {string} description - 任务描述
     * @returns {Object} 创建的任务对象
     */
    createTask(name, estimatedPomodoros = 1, description = '') {
        if (!name || name.trim() === '') {
            throw new Error('任务名称不能为空');
        }

        const task = {
            id: this.taskIdCounter++,
            name: name.trim(),
            description: description.trim(),
            estimatedPomodoros: Math.max(1, parseInt(estimatedPomodoros) || 1),
            completedPomodoros: 0,
            completed: false,
            createdAt: new Date().toISOString(),
            completedAt: null,
            sessions: [] // 记录每次番茄时钟会话
        };

        this.tasks.push(task);
        this.saveTasks();
        
        return task;
    }

    /**
     * 更新任务
     * @param {number} taskId - 任务ID
     * @param {Object} updates - 更新的字段
     * @returns {Object|null} 更新后的任务对象
     */
    updateTask(taskId, updates) {
        const task = this.getTask(taskId);
        if (!task) {
            return null;
        }

        // 验证更新字段
        if (updates.name !== undefined) {
            if (!updates.name || updates.name.trim() === '') {
                throw new Error('任务名称不能为空');
            }
            task.name = updates.name.trim();
        }

        if (updates.description !== undefined) {
            task.description = updates.description.trim();
        }

        if (updates.estimatedPomodoros !== undefined) {
            task.estimatedPomodoros = Math.max(1, parseInt(updates.estimatedPomodoros) || 1);
        }

        if (updates.completed !== undefined) {
            task.completed = Boolean(updates.completed);
            task.completedAt = task.completed ? new Date().toISOString() : null;
        }

        this.saveTasks();
        return task;
    }

    /**
     * 删除任务
     * @param {number} taskId - 任务ID
     * @returns {boolean} 是否删除成功
     */
    deleteTask(taskId) {
        const index = this.tasks.findIndex(task => task.id === taskId);
        if (index === -1) {
            return false;
        }

        // 如果删除的是当前任务，清除当前任务
        if (this.currentTaskId === taskId) {
            this.currentTaskId = null;
        }

        this.tasks.splice(index, 1);
        this.saveTasks();
        return true;
    }

    /**
     * 清除所有已完成的任务
     * @returns {number} 清除的任务数量
     */
    clearCompletedTasks() {
        const completedTasks = this.tasks.filter(task => task.completed);
        const clearedCount = completedTasks.length;

        // 如果当前任务是已完成的任务，清除当前任务ID
        if (this.currentTaskId && completedTasks.some(task => task.id === this.currentTaskId)) {
            this.currentTaskId = null;
        }

        this.tasks = this.tasks.filter(task => !task.completed);
        this.saveTasks();

        return clearedCount;
    }

    /**
     * 切换任务完成状态
     * @param {number} taskId - 任务ID
     * @returns {boolean} 切换后的完成状态
     */
    toggleTaskComplete(taskId) {
        const task = this.getTask(taskId);
        if (!task) {
            throw new Error('任务不存在');
        }

        const newCompletedState = !task.completed;
        this.updateTask(taskId, { completed: newCompletedState });

        // 如果任务被标记为未完成，且它是当前任务，则清除当前任务
        if (!newCompletedState && this.currentTaskId === taskId) {
            this.currentTaskId = null;
        }

        return newCompletedState;
    }

    /**
     * 增加任务的番茄时钟完成数
     * @param {number} taskId - 任务ID
     * @returns {Object} 更新后的任务
     */
    incrementTaskPomodoros(taskId) {
        const task = this.getTask(taskId);
        if (!task) {
            throw new Error('任务不存在');
        }

        task.completedPomodoros++;

        // 检查任务是否应该标记为完成
        if (task.completedPomodoros >= task.estimatedPomodoros && !task.completed) {
            task.completed = true;
            task.completedAt = new Date().toISOString();
        }

        this.saveTasks();
        return task;
    }

    /**
     * 获取任务
     * @param {number} taskId - 任务ID
     * @returns {Object|null} 任务对象
     */
    getTask(taskId) {
        return this.tasks.find(task => task.id === taskId) || null;
    }

    /**
     * 获取所有任务
     * @param {Object} options - 筛选选项
     * @returns {Array} 任务列表
     */
    getAllTasks(options = {}) {
        let filteredTasks = [...this.tasks];

        // 按完成状态筛选
        if (options.completed !== undefined) {
            filteredTasks = filteredTasks.filter(task => task.completed === options.completed);
        }

        // 按排序方式排序
        if (options.sortBy) {
            filteredTasks.sort((a, b) => {
                switch (options.sortBy) {
                    case 'name':
                        return a.name.localeCompare(b.name);
                    case 'created':
                        return new Date(b.createdAt) - new Date(a.createdAt);
                    case 'progress':
                        const progressA = a.estimatedPomodoros > 0 ? a.completedPomodoros / a.estimatedPomodoros : 0;
                        const progressB = b.estimatedPomodoros > 0 ? b.completedPomodoros / b.estimatedPomodoros : 0;
                        return progressB - progressA;
                    default:
                        return 0;
                }
            });
        }

        return filteredTasks;
    }

    /**
     * 设置当前任务
     * @param {number|null} taskId - 任务ID，null表示清除当前任务
     * @returns {Object|null} 当前任务对象
     */
    setCurrentTask(taskId) {
        if (taskId === null) {
            this.currentTaskId = null;
        } else {
            const task = this.getTask(taskId);
            if (!task) {
                throw new Error('任务不存在');
            }
            if (task.completed) {
                throw new Error('不能选择已完成的任务');
            }
            this.currentTaskId = taskId;
        }

        this.saveTasks();
        this.notifyListeners('currentTaskChanged', { 
            currentTask: this.getCurrentTask() 
        });
        
        return this.getCurrentTask();
    }

    /**
     * 获取当前任务
     * @returns {Object|null} 当前任务对象
     */
    getCurrentTask() {
        return this.currentTaskId ? this.getTask(this.currentTaskId) : null;
    }

    /**
     * 记录番茄时钟完成
     * @param {Object} sessionData - 会话数据
     */
    recordPomodoroSession(sessionData) {
        const currentTask = this.getCurrentTask();
        if (!currentTask) {
            return;
        }

        // 记录会话信息
        const session = {
            startTime: sessionData.startTime,
            endTime: sessionData.endTime,
            duration: sessionData.duration,
            type: sessionData.type, // 'work', 'shortBreak', 'longBreak'
            completed: sessionData.completed
        };

        currentTask.sessions.push(session);

        // 如果是工作会话且完成了，增加完成的番茄数
        if (sessionData.type === 'work' && sessionData.completed) {
            currentTask.completedPomodoros++;
            
            // 检查任务是否完成
            if (currentTask.completedPomodoros >= currentTask.estimatedPomodoros) {
                this.updateTask(currentTask.id, { completed: true });
            }
        }

        this.saveTasks();
    }

    /**
     * 获取任务统计信息
     * @returns {Object} 统计信息
     */
    getTaskStatistics() {
        const stats = {
            total: this.tasks.length,
            completed: 0,
            inProgress: 0,
            totalPomodoros: 0,
            completedPomodoros: 0,
            averagePomodoros: 0,
            completionRate: 0,
            tasks: []
        };

        this.tasks.forEach(task => {
            if (task.completed) {
                stats.completed++;
            } else if (task.completedPomodoros > 0) {
                stats.inProgress++;
            }

            stats.totalPomodoros += task.estimatedPomodoros;
            stats.completedPomodoros += task.completedPomodoros;

            // 任务详细统计
            const taskStats = {
                id: task.id,
                name: task.name,
                estimatedPomodoros: task.estimatedPomodoros,
                completedPomodoros: task.completedPomodoros,
                progress: task.estimatedPomodoros > 0 ? 
                    (task.completedPomodoros / task.estimatedPomodoros * 100).toFixed(1) : 0,
                completed: task.completed,
                efficiency: this.calculateTaskEfficiency(task)
            };

            stats.tasks.push(taskStats);
        });

        // 计算平均值和完成率
        if (stats.total > 0) {
            stats.averagePomodoros = (stats.totalPomodoros / stats.total).toFixed(1);
            stats.completionRate = (stats.completed / stats.total * 100).toFixed(1);
        }

        return stats;
    }

    /**
     * 计算任务效率
     * @param {Object} task - 任务对象
     * @returns {Object} 效率信息
     */
    calculateTaskEfficiency(task) {
        const efficiency = {
            estimatedVsActual: 0,
            timeSpent: 0,
            averageSessionTime: 0,
            focusRate: 0
        };

        if (task.sessions.length === 0) {
            return efficiency;
        }

        // 计算总时间和平均会话时间
        const workSessions = task.sessions.filter(s => s.type === 'work');
        const totalTime = workSessions.reduce((sum, s) => sum + s.duration, 0);
        const completedSessions = workSessions.filter(s => s.completed);

        efficiency.timeSpent = Math.round(totalTime / 60); // 转换为分钟
        efficiency.averageSessionTime = workSessions.length > 0 ? 
            Math.round(totalTime / workSessions.length / 60) : 0;
        efficiency.focusRate = workSessions.length > 0 ? 
            (completedSessions.length / workSessions.length * 100).toFixed(1) : 0;

        // 预估vs实际对比
        if (task.completed && task.estimatedPomodoros > 0) {
            efficiency.estimatedVsActual = 
                (task.completedPomodoros / task.estimatedPomodoros * 100).toFixed(1);
        }

        return efficiency;
    }

    /**
     * 导出任务数据
     * @returns {string} JSON格式的任务数据
     */
    exportTasks() {
        const exportData = {
            tasks: this.tasks,
            currentTaskId: this.currentTaskId,
            taskIdCounter: this.taskIdCounter,
            exportTime: new Date().toISOString(),
            version: '1.0'
        };

        return JSON.stringify(exportData, null, 2);
    }

    /**
     * 导入任务数据
     * @param {string} jsonData - JSON格式的任务数据
     * @param {boolean} merge - 是否合并数据（默认覆盖）
     * @returns {boolean} 是否导入成功
     */
    importTasks(jsonData, merge = false) {
        try {
            const importData = JSON.parse(jsonData);
            
            // 验证数据格式
            if (!importData.tasks || !Array.isArray(importData.tasks)) {
                throw new Error('无效的任务数据格式');
            }

            if (merge) {
                // 合并模式：添加新任务，更新ID计数器
                const maxId = Math.max(
                    this.taskIdCounter - 1,
                    ...importData.tasks.map(t => t.id || 0)
                );
                
                importData.tasks.forEach(task => {
                    if (!this.getTask(task.id)) {
                        this.tasks.push(task);
                    }
                });
                
                this.taskIdCounter = maxId + 1;
            } else {
                // 覆盖模式：完全替换
                this.tasks = importData.tasks;
                this.currentTaskId = importData.currentTaskId || null;
                this.taskIdCounter = importData.taskIdCounter || 1;
            }

            this.saveTasks();
            return true;
        } catch (error) {
            console.error('导入任务数据失败:', error);
            return false;
        }
    }

    /**
     * 重置所有任务数据
     */
    resetTasks() {
        this.tasks = [];
        this.currentTaskId = null;
        this.taskIdCounter = 1;
        this.saveTasks();
    }

    /**
     * 添加事件监听器
     * @param {Function} listener - 监听器函数
     */
    addListener(listener) {
        this.listeners.push(listener);
    }

    /**
     * 移除事件监听器
     * @param {Function} listener - 监听器函数
     */
    removeListener(listener) {
        const index = this.listeners.indexOf(listener);
        if (index > -1) {
            this.listeners.splice(index, 1);
        }
    }

    /**
     * 通知所有监听器
     * @param {string} event - 事件类型
     * @param {Object} data - 事件数据
     */
    notifyListeners(event, data) {
        this.listeners.forEach(listener => {
            try {
                listener(event, data);
            } catch (error) {
                console.error('任务管理器监听器错误:', error);
            }
        });
    }

    /**
     * 获取存储信息
     * @returns {Object} 存储信息
     */
    getStorageInfo() {
        const data = localStorage.getItem('pomodoroTasks');
        return {
            size: data ? new Blob([data]).size : 0,
            taskCount: this.tasks.length,
            lastModified: new Date().toISOString()
        };
    }
}

// 导出TaskManager类
if (typeof module !== 'undefined' && module.exports) {
    module.exports = TaskManager;
}